Numbers



In [ ]:

    
1 + 1



In [ ]:

    
1 + 1.0



In [ ]:

    
typeof(1)



In [ ]:

    
typeof(1.0)



In [ ]:

    
typeof(Float64)



In [ ]:

    
bits(1)



In [ ]:

    
bits(1.0)

Strings



In [ ]:

    
str1 = "Hello, world."



In [ ]:

    
str2 = "\u2200 x \u2203 y s.t. f(y) > x"



In [ ]:

    
typeof(str1)



In [ ]:

    
typeof(str2)



In [ ]:

    
xdump(str1)



In [ ]:

    
str2.data



In [ ]:

    
str2[1]



In [ ]:

    
str2[2]



In [ ]:

    
str2[3]



In [ ]:

    
str2[4]

Vectors and Matrices



In [ ]:

    
[1, 2, 3]



In [ ]:

    
[1 2;
 3 4;]



In [ ]:

    
[1 2 3;
 4 5 6;
 7 8 9;] * [1, 2, 3]

Iteration



In [ ]:

    
itr = 1:5
for x in itr
  println(x)
end



In [ ]:

    
itr = 1:5
state = start(itr)
while !done(itr,state)
  x, state = next(itr,state)
  println(x)
end

Math Constants



In [ ]:

    
pi



In [ ]:

    
typeof(pi)



In [ ]:

    
2pi



In [ ]:

    
big(2)*pi



In [ ]:

    
big(2pi)

BigInts and BigFloats (and Rounding Modes)



In [ ]:

    
big(1234)



In [ ]:

    
typeof(big(1234))



In [ ]:

    
big(2)^100



In [ ]:

    
(3//big(4))^80



In [ ]:

    
float((3//big(4))^80)



In [ ]:

    
set_bigfloat_precision(100)



In [ ]:

    
1/big(7)



In [ ]:

    
with_bigfloat_precision(90) do
  1/big(7)
end



In [ ]:

    
get_bigfloat_precision()



In [ ]:

    
0.1 + 0.2



In [ ]:

    
with_rounding(RoundDown) do
  0.1 + 0.2
end

Functions



In [ ]:

    
double(x) = x + x



In [ ]:

    
double(1)



In [ ]:

    
double(1.0)



In [ ]:

    
triple(x) = x + x + x



In [ ]:

    
triple(1)



In [ ]:

    
triple(1.0)



In [ ]:

    
id(x) = x



In [ ]:

    
id(1)



In [ ]:

    
id("a")



In [ ]:

    
function qux(x, y::Real = 1.0; z = pi)
  return x + y + z
end



In [ ]:

    
qux(1)



In [ ]:

    
qux(1, 1.0, z=pi)



In [ ]:

    
qux(1, 2)



In [ ]:

    
qux(1, z = e)



In [ ]:

    
qux(1, 2, z = 3)



In [ ]:

    
qux(1, "a", z = 4)



In [ ]:

    
bar(x::Real) = x^2



In [ ]:

    
code_llvm(bar, (Int, ))



In [ ]:

    
code_llvm(bar, (Float64, ))



In [ ]:

    
function collatz(n::Integer)
    path = Int[n]
    while n != 1
        if iseven(n)
            n = fld(n, 2)
        else
            n = 3n + 1
        end
        push!(path, n)
    end
    return path
end



In [ ]:

    
collatz(3)



In [ ]:

    
code_llvm(collatz, (Int,))

Collections



In [ ]:

    
[1,2,3]



In [ ]:

    
[1,pi,3.5]



In [ ]:

    
[1,pi,"Hello"]



In [ ]:

    
["a" => 1, "b" => 2]



In [ ]:

    
typeof(["a" => 1, "b" => 2])



In [ ]:

    
{"a" => 1, "b" => 2}



In [ ]:

    
typeof({"a" => 1, "b" => 2})

Types



In [ ]:

    
{1, 2, 3}



In [ ]:

    
a = [x + y*im for x = randn(2), y = randn(2)]



In [ ]:

    
sizeof(a)



In [ ]:

    
sizeof(a[1])



In [ ]:

    
size(a)

Mutable Composite Types



In [ ]:

    
type Foo
  x::Int64
  y::Float64
end



In [ ]:

    
foo = Foo(1, 2.5)



In [ ]:

    
foo.x = 2



In [ ]:

    
foo2 = foo



In [ ]:

    
foo2.x = 3



In [ ]:

    
foo



In [ ]:

    
foos = [foo, foo, foo]



In [ ]:

    
sizeof(foos) # 3 x 64-bit pointers [to tagged, heap-allocated values]

Immutable Composite Types



In [ ]:

    
immutable Bar
  x::Int64
  y::Float64
end



In [ ]:

    
baz = Bar(1,2.5)



In [ ]:

    
baz.x = 2



In [ ]:

    
sizeof(baz)



In [ ]:

    
bazes = [baz, baz, baz]



In [ ]:

    
sizeof(bazes) # 3 x (8-byte Int64 + 8-byte Float64)

Abstract Types



In [ ]:

    
Int <: Number



In [ ]:

    
Float64 <: Number



In [ ]:

    
ASCIIString <: Number



In [ ]:

    
h(x::Number) = 1



In [ ]:

    
h(x::Float64) = 2



In [ ]:

    
h(x::Integer) = 3



In [ ]:

    
h(1), h(1.5), h(1+2im)



In [ ]:

    
z = 1 + 2im



In [ ]:

    
isa(z, Number)



In [ ]:

    
typeof(z)

Parametric Types

See base/complex.jl and base/rational.jl for nice built-in examples.



In [ ]:

    
z = Complex(1,2)



In [ ]:

    
typeof(z)



In [ ]:

    
Complex{Int}



In [ ]:

    
Complex



In [ ]:

    
Complex{Rational{Int}}



In [ ]:

    
rz = 1//2 + 3//4*im



In [ ]:

    
typeof(rz)



In [ ]:

    
rz + pi

Modules (Namespaces)



In [ ]:

    
module TMP
  a = 1
  b = "a"
  c = [1, 2.0]
end



In [ ]:

    
a



In [ ]:

    
TMP.a

Packages



In [ ]:

    
require("Stats")



In [ ]:

    
Stats.gmean([1, 2, 3])



In [ ]:

    
gmean([1, 2, 3])



In [ ]:

    
using Stats



In [ ]:

    
gmean([1, 2, 3])